package org.wdcode.common.tools;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.wdcode.common.util.CommonUtil;

/**
 * List的帮助类
 * @author WD
 * @since JDK6
 * @version 1.0 2009-09-08
 */
public final class Lists {
	/**
	 * 获得List实例 默认初始化大小为10
	 * @return List
	 */
	public final static <E> List<E> getList() {
		return getArrayList();
	}

	/**
	 * 获得List实例
	 * @param size 初始化大小
	 * @return List
	 */
	public final static <E> List<E> getList(int size) {
		return getArrayList(size);
	}

	/**
	 * 获得List实例
	 * @param c 初始化的集合
	 * @return List
	 */
	public final static <E> List<E> getList(Collection<E> c) {
		return getArrayList(c);
	}

	/**
	 * 获得List实例
	 * @param c 初始化的集合
	 * @return List
	 */
	public final static <E> List<E> getList(Collection<E>... c) {
		// 获得一个列表
		List<E> list = getList();
		// 循环集合
		for (int i = 0; i < c.length; i++) {
			// 添加到列表中
			list.addAll(c[i]);
		}
		// 返回列表
		return list;
	}

	/**
	 * 获得List实例
	 * @param es 初始化的数组
	 * @return List
	 */
	public final static <E> List<E> getList(E... e) {
		return getList(Arrays.toList(e));
	}

	/**
	 * 获得List实例 实现类是ArrayList 默认初始化大小为10
	 * @return List
	 */
	public final static <E> ArrayList<E> getArrayList() {
		return getArrayList(10);
	}

	/**
	 * 获得List实例 实现类是ArrayList
	 * @param size 初始化大小
	 * @return List
	 */
	public final static <E> ArrayList<E> getArrayList(int size) {
		return new ArrayList<E>(size);
	}

	/**
	 * 获得List实例 实现类是ArrayList
	 * @param c 初始化的集合
	 * @return List
	 */
	public final static <E> ArrayList<E> getArrayList(Collection<E> c) {
		return new ArrayList<E>(c);
	}

	/**
	 * 获得List实例 实现类是ArrayList
	 * @param es 初始化的数组
	 * @return List
	 */
	public final static <E> List<E> getArrayList(E... e) {
		return getArrayList(Arrays.toList(e));
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @return 同步的List
	 */
	public final static <E> CopyOnWriteArrayList<E> getConcurrenrList() {
		return new CopyOnWriteArrayList<E>();
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @param e 初始化数组
	 * @return 同步的List
	 */
	public final static <E> CopyOnWriteArrayList<E> getConcurrenrList(E... e) {
		return new CopyOnWriteArrayList<E>(e);
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @param c 初始化的集合
	 * @return 同步的List
	 */
	public final static <E> CopyOnWriteArrayList<E> getConcurrenrList(Collection<E> c) {
		return new CopyOnWriteArrayList<E>(c);
	}

	/**
	 * 获得同步的List实例 实现类是ArrayList 默认初始化大小为10
	 * @return 同步的List
	 */
	public final static <E> List<E> getSyncList() {
		return getSyncList(10);
	}

	/**
	 * 获得同步的List实例 实现类是ArrayList
	 * @param size 初始化大小
	 * @return 同步的List
	 */
	public final static <E> List<E> getSyncList(int size) {
		List<E> list = getList(size);
		return Collections.synchronizedList(list);
	}

	/**
	 * 获得同步的List实例 实现类是ArrayList
	 * @param c 初始化的集合
	 * @return 同步的List
	 */
	public final static <E> List<E> getSyncList(Collection<E> c) {
		return Collections.synchronizedList(getList(c));
	}

	/**
	 * 获得List实例 实现类是ArrayList
	 * @param es 初始化的数组
	 * @return List
	 */
	public final static <E> List<E> getSyncList(E... e) {
		return getSyncList(Arrays.toList(e));
	}

	/**
	 * 获得同步的List实例 实现类是LinkedList
	 * @return 同步的List
	 */
	public final static <E> LinkedList<E> getLinkedList() {
		return new LinkedList<E>();
	}

	/**
	 * 获得同步的List实例 实现类是LinkedList
	 * @param c 初始化的集合
	 * @return 同步的List
	 */
	public final static <E> LinkedList<E> getLinkedList(Collection<E> c) {
		return new LinkedList<E>(c);
	}

	/**
	 * 获得List实例 实现类是LinkedList
	 * @param es 初始化的数组
	 * @return List
	 */
	public final static <E> List<E> getLinkedList(E... e) {
		return getLinkedList(Arrays.toList(e));
	}

	/**
	 * 返回列表从firstResult开始返回maxResults个元素
	 * @param list 元素列表
	 * @param begin 重begin开始取元素
	 * @param end 到end为止
	 * @return 返回获得元素列表
	 */
	public final static <E> List<E> getList(List<E> list, int firstResult, int maxResults) {
		// 如果列表为空返回一个空列表
		if (CommonUtil.isEmpty(list) || maxResults < 1) {
			return Collections.emptyList();
		}
		// 获得元列表大小
		int size = list.size();
		// 判断如果firstResult大于等于元素列表大小 返回一个空列表
		if (maxResults >= size) {
			return Collections.emptyList();
		}
		// 判断firstResult
		firstResult = firstResult < 0 ? 0 : firstResult;
		// 判断maxResults
		maxResults = (firstResult + maxResults) > size ? size - firstResult : maxResults;
		// 获得循环长度
		int len = firstResult + maxResults;
		// 声明一个保存结果的列表
		List<E> ls = getList(maxResults);
		// 循环获得元素
		for (int i = firstResult; i < len; i++) {
			// 添加元素
			ls.add(list.get(i));
		}
		// 返回列表
		return ls;
	}

	/**
	 * 给List排序
	 * @param list 要排序的List
	 * @return 排完序的List
	 */
	public final static <E extends Comparable<? super E>> List<E> sort(List<E> list) {
		// 排序
		Collections.sort(list);
		// 返回list
		return list;
	}

	/**
	 * 获得一个不可变的空List
	 * @return 一个不可变的空List
	 */
	public final static <E> List<E> emptyList() {
		return Collections.emptyList();
	}

	/**
	 * 私有构造 禁止外部实例化
	 */
	private Lists() {}
}
